﻿#define _CRT_SECURE_NO_WARNINGS

//#include<iostream>
//using namespace std;
//class A
//{
//public:
//	A()
//	{
//		cout << "A()" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//class B
//{
//public:
//	B()
//	{
//		cout << "B()" << endl;
//	}
//	~B()
//	{
//		cout << "~B()" << endl;
//	}
//};
//class C
//{
//public:
//	C()
//	{
//		cout << "C()" << endl;
//	}
//	~C()
//	{
//		cout << "~C()" << endl;
//	}
//};
//class D
//{
//public:
//	D()
//	{
//		cout << "D()" << endl;
//	}
//	~D()
//	{
//		cout << "~D()" << endl;
//	}
//};
//class E
//{
//public:
//	E()
//	{
//		cout << "E()" << endl;
//	}
//	~E()
//	{
//		cout << "~E()" << endl;
//	}
//};
//C c;
//
//int main()
//{
//
//	A* pa = new A();
//
//	B b;
//
//	static D d;
//
//	E e;
//
//	delete pa;
//
//	return 0;
//}
//
//#include<iostream>
//using namespace std;
//class A
//{
//private:
//	static int _a;
//	int _b = 1;
//public:
//	class C
//		//C如果在A的private里面，就不可以在类外面访问
//	{
//	public:
//		void func(const A& a)
//		{
//			cout << _a << endl; //OK//可以直接访问A的静态变量（所有类对象共享）
//			cout << a._a << endl; //OK//也可以使用对象访问A的静态变量
//			//cout << _b << endl; //err  //_b是非静态变量，需要对象访问
//			cout << a._b << endl; //OK//使用对象访问A的非静态变量
//			// C默认就是A的友元
//			//可以访问A的成员变量
//		}
//		int _c;
//	};
//};
//int A::_a = 1;
//int main()
//{
//	cout << sizeof(A) << endl;
//	//内部类是⼀个独立的类,这里A大小为4
//	// （只计算成员变量_b,_c是static成员为所有对象共享)，与C的成员变量无关
//	//C c;//err//不可以直接定义C类对象
//	A::C c;//内部类受外部类类域限制和访问限定符限制
//	A aa;
//	c.func(aa);
//	return 0;
//}

////优化封装
//class Solution {
//    class sum
//    {
//    public:
//        sum()
//        {
//            _c++;//从1~n
//            _ret += _c;//累加求和
//        }
//    };//不写默认为私有类，不想被别人使用
//public:
//    int Sum_Solution(int n) {
//        //static成员为所有对象共享
//        //产生n个对象就可以实现累加
//        //sum arr[n];//变长数组
//        sum* a = new sum[n];//动态开辟
//        return _ret;
//    }
//private:
//    static int _c;
//    static int _ret;//外部类私有成员变量，内部类和外部类都可以访问
//};
////Solution::sum s;//err 类外部不可以访问私有成员
////静态成员类外指定类域初始化
//int Solution::_c = 0;
//int Solution::_ret = 0;


//#include<iostream>
//using namespace std;
//class A
//{
//public:
//	A(int a = 0)
//		:_a1(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	A(const A& aa)
//		:_a1(aa._a1)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//		{
//			_a1 = aa._a1;
//		}
//		return *this;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a1 = 1;
//};
//void f1(A aa)
//{}
//A f2()
//{
//	A aa;
//	return aa;
//}
//int main()
//{
//	// 传值传参
//	// 构造+拷贝构造
//	A aa1;
//	f1(aa1);
//	cout << endl;
//
//	// 隐式类型，连续构造+拷贝构造->优化为直接构造
//	f1(1);
//	// ⼀个表达式中，连续构造+拷贝构造->优化为一个构造
//	f1(A(2));
//	cout << endl;
//
//	// 传值返回
//	// 不优化的情况下传值返回，编译器会生成一个拷贝返回对象的临时对象作为函数调用表达式的返回值
//	// 无优化 （vs2019 debug）
//	// ⼀些编译器会优化得更厉害，将构造的局部对象和拷贝构造的临时对象优化为直接构造（vs2022 debug）
//	f2();
//	cout << endl;
//
//	// 返回一个表达式中，连续拷贝构造+拷贝构造->优化⼀个拷贝构造 （vs2019 debug）
//	// ⼀些编译器会优化得更厉害，进行跨行合并优化，将构造的局部对象aa和拷⻉的临时对象和接收返回值对象aa2优化为⼀个直接构造。（vs2022 debug）
//	A aa2 = f2();
//	cout << endl;
//
//	// ⼀个表达式中，开始构造，中间拷贝构造+赋值重载->无法优化（vs2019 debug）
//	// 一些编译器会优化得更厉害，进行跨行合并优化，将构造的局部对象aa和拷贝临时对象合并为⼀个直接构造（vs2022 debug）
//	aa1 = f2();
//	cout << endl;
//	return 0;
//}
